package com.lfz.demo.controller;

import com.lfz.demo.entity.Notice;
import com.lfz.demo.entity.PopulationNews;
import com.lfz.demo.service.ChinaTotalService;
import com.lfz.demo.service.NoticeService;
import com.lfz.demo.service.PopulationNewsService;
import com.lfz.demo.utils.RedisUtil;
import com.lfz.demo.vo.DataView;
import org.apache.shiro.SecurityUtils;
import org.apache.shiro.subject.Subject;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;

import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;

import java.text.ParseException;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
 * @author lfz
 * @date 2025/3/10 17:20
 * Model 是 java的一个存储容器
 * 专门跳转页面的路由包
 */
@Controller
public class ApiController {

    private static final Logger logger = LoggerFactory.getLogger(RedisUtil.class);
    // 缓存时间常量（单位：分钟）
    private static final int CACHE_EXPIRE = 60; //缓存过期时间（60分钟）。
    private static final String CACHE_PREFIX = "api:"; //缓存键前缀，避免键冲突。

    @Autowired
    private PopulationNewsService populationNewsService;
    @Autowired
    private NoticeService noticeService;
    @Autowired
    private ChinaTotalService chinaTotalService;
    @Autowired
    private RedisUtil redisUtil;

    // 跳转到主控（根）页面
    @GetMapping("/")
    public String index(){
        return "index";
    }

    // 跳转到pie页面(饼图)
    @GetMapping("/toPie")
    public String toPie(){
        return "Visualization/pie";
    }

    // 跳转到bar页面(柱状图)
    @GetMapping("/toBar")
    public String toBar(){
        return "Visualization/bar";
    }

    // 跳转到line页面(折线图-七次全国人口普查趋势)
    @GetMapping("/toLine")
    public String toLine(){
        return "Visualization/line";
    }

    // 跳转china地图页面
    @GetMapping("/toChina")
    public String china(Model model) throws ParseException {
        String cacheKey = CACHE_PREFIX + "newsAndNoticeListData:";

        try {
            // 尝试从 Redis 获取缓存数据
            Map<String, Object> cachedData = (Map<String, Object>) redisUtil.get(cacheKey);
            if (cachedData != null) {
                model.addAllAttributes(cachedData);
                return "Visualization/china"; // 如果有缓存数据，直接返回页面
            }
        } catch (Exception e){
            e.printStackTrace();
            logger.error("Redis连接异常，降级到MySQL查询", e);
        }

        try {
            // 人口播报新闻列表
            List<PopulationNews> newsList = populationNewsService.listNewsLimit3();
            String newsList1 = String.valueOf(model.addAttribute("newsList", newsList));

            // 公告/通知列表
            List<Notice> noticeList = noticeService.listByStatusLimit3();
            String noticeList1 = String.valueOf(model.addAttribute("noticeList", noticeList));

            // 将需要缓存的数据存入 Map
            Map<String, Object> dataToCache = new HashMap<>();
            dataToCache.put("newsList", newsList);
            dataToCache.put("noticeList", noticeList);

            // 设置redis缓存
            redisUtil.set(cacheKey, dataToCache, CACHE_EXPIRE);

        } catch (Exception e){
            e.printStackTrace();
            logger.error("新闻、公告/通知查询异常", e);
        }

        return "Visualization/china";
    }

    // 跳转中国人口数据管理
    @GetMapping("/china/toChinaManager")
    public String toChinaManager(){
        return "Admin/chinadatamanager";
    }

    // 跳转到操作日志页面
    @GetMapping("/logs/toLog")
    public String toLog(){
        return "Sys/Logs/operationLog";
    }

    // 跳转到global页面(全球人口地图)
    @GetMapping("/toGlobal")
    public String toGlobal(){
        return "Visualization/global";
    }

    //@return "login";    跳转到登录页面
    @GetMapping("/toLogin")
    public String toLogin(){
        return "login";
    }

    // 跳转到注册页面
    @GetMapping("/toRegister")
    public String register() { return "register"; }

    // 跳转到登出链接（登录）页面
    @GetMapping("/logout")
    public String logout(){
        Subject subject = SecurityUtils.getSubject();
        subject.logout();
        return "login";
    }

    // 跳转到找回密码页面
    @GetMapping("/findPwd")
    public String findPwd(){
        return "findPwd";
    }

    // 跳转到菜单管理页面
    @GetMapping("/menu/toMenu")
    public String toMenu(){
        return "Sys/Menu/menu";
    }

    // 跳转到新闻管理页面
    @GetMapping("/news/toNews")
    public String toNews(){
        return "News/newsmanager";
    }

    // 跳转到角色管理页面
    @GetMapping("/role/toRole")
    public String toRole(){
        return "Sys/Role/role";
    }

    // 跳转 用户管理页面
    @GetMapping("/user/toUserManager")
    public String toUserManager() {
        return "Sys/User/userManager";
    }

    // 跳转 个人中心页面
    @GetMapping("/user/toUser")
    public String toUser() {
        return "Sys/User/user";
    }

    // 跳转 用户个人信息页面
    @GetMapping("/user/toUserInfo")
    public String toUserInfo() {
        return "Sys/User/userInfo";
    }

    // 跳转 修改密码页面
    @GetMapping("/user/toChangePassword")
    public String toChangePassword() {
        return "Sys/User/changePassword";
    }

    // 跳转 系统公告管理
    @GetMapping("/notice/toNotice")
    public String toNotice(){
        return "Notice/noticeManager";
    }

    // 跳转 新闻详情页
    @GetMapping("/news/detail/{id}")
    public String newsDetail(@PathVariable Integer id, Model model) {
        String cacheKey = CACHE_PREFIX + "newsDetail:" +id; // 生成缓存键，加入新闻 id 到缓存键，保证每个新闻详情都有独一无二的缓存键

        try {
            // 尝试从 Redis 获取缓存数据
            Map<String, Object> cachedData = (Map<String, Object>) redisUtil.get(cacheKey);
            if (cachedData != null){
                model.addAllAttributes(cachedData);
                return "News/detail"; // 如果有有效的缓存数据，直接返回页面
            }
        } catch (Exception e){
            e.printStackTrace();
            logger.error("Redis连接异常，降级到MySQL查询", e);
        }

        try {
            PopulationNews news = populationNewsService.getById(id);
            model.addAttribute("news", news);

            // 将需要缓存的数据存入 Map
            Map<String, Object> dataToCache = new HashMap<>();
            dataToCache.put("news", news);

            // 设置redis缓存
            redisUtil.set(cacheKey, dataToCache, CACHE_EXPIRE);
        }catch (Exception e){
            e.printStackTrace();
            logger.error("新闻详情查询异常", e);
        }
        return "News/detail";
    }

    // 跳转 历史新闻列表 浏览页面
    @GetMapping("/toPastNews")
    public String pastNews(Model model) {
        String cacheKey = CACHE_PREFIX + "pastNews";    // 生成缓存键

        try {
            // 尝试从redis获取数据
            Map<String, Object> cachedData = (Map<String, Object>) redisUtil.get(cacheKey);
            if (cachedData != null){
                model.addAllAttributes(cachedData);
                return "News/past_news"; // 如果有有效的缓存数据，直接返回页面

            }
        }catch (Exception e){
            e.printStackTrace();
            logger.error("Redis连接异常，降级到MySQL查询", e);
        }

        try {
            // 获取所有历史新闻，按照时间最新到最久排列展示
            List<PopulationNews> pastNewsList = populationNewsService.pastNewsListDesc();
            model.addAttribute("pastNewsList", pastNewsList);

            // 将需要缓存的数据存入 Map
            Map<String, Object> dataToCache = new HashMap<>();
            dataToCache.put("pastNewsList", pastNewsList);

            // 设置redis缓存
            redisUtil.set(cacheKey, dataToCache, CACHE_EXPIRE);

        }catch (Exception e){
            e.printStackTrace();
            logger.error("历史新闻查询异常", e);
        }
        return "News/past_news";
    }

    // 跳转 公告/通知详情页
    @GetMapping("/notice/detail/{id}")
    public String noticeDetail(@PathVariable Integer id, Model model) {
        String cacheKey = CACHE_PREFIX + "noticeDetail" + id;    // 生成缓存键，加入公告/通知 id 到缓存键，保证每个公告/通知详情都有独一无二的缓存键

        try {
            // 尝试从redis获取数据
            Map<String, Object> cachedData = (Map<String, Object>) redisUtil.get(cacheKey);
            if (cachedData != null){
                model.addAllAttributes(cachedData);
                return "Notice/detail"; // 如果有有效的缓存数据，直接返回页面
            }
        } catch (Exception e){
          e.printStackTrace();
          logger.error("Redis连接异常，降级到MySQL查询", e);
        }

        try {
            Notice notices = noticeService.getById(id);
            model.addAttribute("notice", notices);

            // 将需要缓存的数据存入 Map
            Map<String, Object> dataToCache = new HashMap<>();
            dataToCache.put("notice", notices);

            // 设置redis缓存
            redisUtil.set(cacheKey, dataToCache, CACHE_EXPIRE);
        } catch (Exception e){
            e.printStackTrace();
            logger.error("公告/通知详情查询异常", e);
        }
        return "Notice/detail";
    }

    // 跳转 历史通知/公告列表 浏览页面
    @GetMapping("/toPastNotice")
    public String pastNotice(Model model) {
        String cacheKey = CACHE_PREFIX + "pastNotice";  // 生成缓存键

        try {
            // 尝试从redis缓存中获取数据
            Map<String, Object> cachedData = (Map<String, Object>) redisUtil.get(cacheKey);
            if (cachedData != null){
                model.addAllAttributes(cachedData);
                return "Notice/past_notice"; // 如果有有效的缓存数据，直接返回页面
            }
        } catch (Exception e){
            e.printStackTrace();
            logger.error("Redis连接异常，降级到MySQL查询", e);
        }

        try {
            List<Notice> pastNoticeList = noticeService.partNoticeListDesc(); // 获取所有公告/通知
            model.addAttribute("pastNoticeList", pastNoticeList);

            // 将需要缓存的数据存入 Map
            Map<String, Object> dataToCache = new HashMap<>();
            dataToCache.put("pastNoticeList", pastNoticeList);

            // 设置redis缓存
            redisUtil.set(cacheKey, dataToCache, CACHE_EXPIRE);
        }catch (Exception e){
            e.printStackTrace();
            logger.error("历史公告/通知查询异常");
        }
        return "Notice/past_notice";
    }

    // 子窗口 更新裁剪头像(个人中心)
    @GetMapping("/avatarUpload")
    public String toAvatarUpload(){
        return "Avatar/avatarUpload";
    }

    // 子窗口 更新裁剪头像(用户管理)
    @GetMapping("/avatarUploadByUid")
    public String toAvatarUploadByUid(){
        return "Avatar/avatarUploadByUid";
    }



}
